home *** CD-ROM | disk | FTP | other *** search
/ DOpus Plus / DOpus Plus.iso / Tutorial / C Guide / Simple_Module2 / DetachWindow / DetachWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-31  |  9.5 KB  |  289 lines
  1. /*******************************************************************
  2.  
  3.    DetachWindow.c
  4.     
  5.     Does detach itself from the starting process and open a simple
  6.     window with some easy gadgets.
  7.     
  8.     To do this detaching we need 2 functions more and since I want
  9.     not change our ModuleEntry.c for this, I must name the first
  10.     function OwnWindow(). 
  11.     
  12.     You may also refer to the IconClock module of the SDK for 
  13.     an other example.
  14.     
  15.     Use ARTM, SnoopDos or similar if you want to check, that really
  16.     an own process is running...                
  17.                     
  18. *********************************************************************/
  19. #define PARENT
  20. #include "/includes/Window.h"
  21.  
  22. // now we need some other variables than in our structure
  23. // WindowHandle...
  24.  
  25. typedef struct _PassingData
  26. {
  27.     ULONG a4;                 // to store a4 (module is a4 relative)
  28.     struct Library *library;  // to store a pointer to dopus5.library 
  29.     struct Library *module;   // to store a pointer to this module
  30.     IPCData *ipc;             // to store our NEW handle
  31.     
  32.     char args[256];           // since we want to use the args in our
  33.                               // detached process, we have to copy it
  34.     
  35.     struct Screen *screen;
  36. }  PassingData;
  37.  
  38. /********************************************************************/
  39. // locale prototypes
  40.  
  41. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  42.                                        register __a1 PassingData *pd );
  43.                                                     
  44. void __saveds New_Proc( void );
  45.  
  46. BOOL OpenDOpusWin( WindowHandle *wh );  // function not changed
  47.  
  48. BOOL HandleWindow( WindowHandle *wh );  // function not changed
  49.  
  50. /********************************************************************/
  51. // this is not the same function like before !
  52. // it is the first special function we need...
  53.  
  54. void OwnWindow( STRPTR args, struct Screen *screen )
  55. {
  56.     IPCData *new_proc = NULL;
  57.     PassingData *pd;
  58.     
  59.     if( (pd = AllocMemH(mempool, sizeof(PassingData))) ) // allocate some memory
  60.       {
  61.           pd->screen = screen;          // store the screen pointer
  62.           strcpy( pd->args, args );     // store our arguments
  63.           
  64.           // now some special stuff, but everything is needed here...
  65.           pd->a4      = getreg( REG_A4 ); 
  66.           pd->module  = (struct Library *) getreg( REG_A6 );
  67.           pd->library = DOpusBase;
  68.           
  69.           // now we are ready to call IPC_Launch()
  70.           IPC_Launch( 0, 
  71.                       &new_proc,        // pointer to pointer to the IPC of the new process, for storing...
  72.                           "ExampleWindow",  // name of the new process
  73.                           (ULONG) New_Proc, // entrypoint of the new process
  74.                           4096,             // stack to use
  75.                           (ULONG) pd,       // data to pass to the new process
  76.                           DOSBase );        // pointer to dos.library
  77.                           
  78.             if( !new_proc )              // if detaching failed...
  79.                  FreeMemH( pd );
  80.         }
  81. }
  82.  
  83. // let's do now the second special function
  84.  
  85. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  86.                                        register __a1 PassingData *pd )
  87. {
  88.     // you may use this function also to setup things for your
  89.     // main process, but you should not call any IPC functions here !
  90.     // we do only the minimum required..., but you will get some small
  91.     // warnings from your compiler. Just ignore them now - they does
  92.     // not appear, if we would do here some more things... 
  93.     
  94.     struct Library *DOpusBase; 
  95.  
  96.     // fix A4
  97.     putreg( REG_A4, pd->a4 );
  98.  
  99.     // store IPC pointer
  100.     pd->ipc = ipc;
  101.  
  102.     // get dopus.library - one warning now
  103.     DOpusBase = pd->library;
  104.  
  105.    // now may follow your initialization
  106.     
  107.     // if something fails and you must quit, you should do:
  108.     // return FALSE;
  109.  
  110.    // increase our library counter, so we can not be flushed
  111.     // do not forget to decrease it, if your detached process ends 
  112.     pd->module->lib_OpenCnt++;
  113.     
  114.     return TRUE; // all was successfully
  115. } 
  116.     
  117.  
  118. void __saveds New_Proc( void )
  119. {
  120.     // this is now just the same like until now our OwnWindow() function
  121.     
  122.     WindowHandle          *wh;
  123.     PassingData           *pd;
  124.     STRPTR                 args;
  125.     IPCData               *ipc;
  126.     struct Library        *DOpusBase;
  127.     
  128.     // but we must do some additional things 
  129.     
  130.     // get dopus library
  131.     if( !(DOpusBase = (struct Library *) FindName(&((struct ExecBase *)*((ULONG *)4))->LibList, "dopus5.library")) )
  132.         return;
  133.     
  134.     // do startup
  135.     ipc = IPC_ProcStartup( (ULONG *) &pd, New_Proc_Startup );
  136.  
  137.     // fix A4 so we can access global data in the module (eg library bases)
  138.     putreg( REG_A4, pd->a4 );
  139.  
  140.     // something failed until now ?
  141.     if( !ipc )
  142.     {
  143.         if( pd )
  144.           {
  145.               IPC_Free( pd->ipc ); // possible it has a value here 
  146.              FreeMemH( pd );      // free our memory
  147.           }
  148.               
  149.         return;
  150.     }
  151.         
  152.     if( (wh = AllocMemH(mempool, sizeof(WindowHandle))) ) // allocate some memory
  153.       {
  154.           // we copy now our values, if you allocate for launching the real
  155.          // structure you need, you must not do this of course... :)
  156.  
  157.          
  158.           wh->screen = pd->screen;     // store the screen pointer
  159.           strncpy( wh->buffer, pd->args, 30 ); // copy our args - limited through our size of wh->buffer...
  160.           wh->buffer[30] = NULL;       // terminate our string
  161.           args = wh->buffer;
  162.           
  163.           // now we can free our PassingData...
  164.           FreeMemH( pd );
  165.           
  166.           // now it is really the same excluding the end ...
  167.           
  168.           if( OpenDOpusWin(wh) )   // open the window
  169.            {
  170.                  // we copy now the arguments into the text gadget
  171.                // if we have supplied some...
  172.                  
  173.                SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) args );
  174.                                                    
  175.                while( TRUE ) 
  176.                   {
  177.                         // I use here Wait(), so it is easier with the changes
  178.                  
  179.                       wh->signals = Wait( 1 << wh->win->UserPort->mp_SigBit );   // wait for window events
  180.                                                         
  181.                       if( wh->signals & 1 << wh->win->UserPort->mp_SigBit )
  182.                             if( HandleWindow(wh) )
  183.                                    break;        // does end the while loop                                       
  184.                      
  185.                   }
  186.              
  187.                CloseConfigWindow( wh->win ); 
  188.              }
  189.              
  190.           FreeMemH( wh ); // free our memory
  191.       }
  192.     
  193.     // since we are here a detached process, we must do some other cleanup too
  194.     IPC_Free( ipc );
  195.     
  196.     // and decrease our Library access counter, since we have increased it before
  197.     ( (struct Library *) getreg(REG_A6) )->lib_OpenCnt--;   
  198.                             
  199. }
  200.  
  201. /********************************************************************/
  202. // This function does open our window. We could have done this in the
  203. // function OwnWindow() too, but we need this function later again.
  204.  
  205. BOOL OpenDOpusWin( WindowHandle *wh )
  206. {
  207.     NewConfigWindow ncfgwin;     // we need a NewConfigWindow structure too
  208.                                  // of couse you could also allocate it with
  209.                                           // AllocMemH()...
  210.     
  211.     // and have to fill it
  212.     
  213.     ncfgwin.nw_Parent = wh->screen;  // open on this screen
  214.     
  215.     // getting a localized title...
  216.     ncfgwin.nw_Title  = DOpusGetString( locale, MSG_WINDOW_TITLE );
  217.     
  218.     ncfgwin.nw_Dims   = &cfgwin; // a pointer to the ConfigWin structure
  219.     ncfgwin.nw_Locale = locale;  // the module locale pointer (from modinit.c)
  220.     ncfgwin.nw_Port   = NULL;    // we doesn't supply a port
  221.     ncfgwin.nw_Font   = NULL;    // just taking the screen font
  222.     ncfgwin.nw_Flags  = WINDOW_REQ_FILL      | // fill with stripple pattern
  223.                         WINDOW_AUTO_KEYS     | // handle keys automatic
  224.                               WINDOW_SCREEN_PARENT;  // nw_Parent points to a screen
  225.     
  226.     if( (wh->win = OpenConfigWindow(&ncfgwin)) )   // open the window
  227.       {
  228.           if( (wh->olist = AddObjectList(wh->win, odef)) ) // add the gadgets
  229.                   return TRUE;
  230.                     
  231.           CloseConfigWindow( wh->win );    //    in error case do not forget :-)
  232.       }
  233.     
  234.     return FALSE;
  235. }
  236.  
  237.  
  238. /********************************************************************/
  239. // we does only close the window, if the closegadget was pressed
  240. // if you want to close it within a gadget, you must only in the
  241. // right case set "stop" to TRUE
  242.  
  243. BOOL HandleWindow( WindowHandle *wh )
  244. {
  245.      BOOL stop = FALSE;
  246.      ULONG value;
  247.      
  248.      while( !stop && (wh->imsg = GetWindowMsg(wh->win->UserPort)) )
  249.         {
  250.             switch( wh->imsg->Class )  // let's handle the IDCMP
  251.               {
  252.                   case IDCMP_GADGETUP:
  253.                                           switch( GET_ID(wh->imsg) )
  254.                                          {
  255.                                                          case GADGET_ID_CYCLE:  // we copy simply the same text to the text gadget
  256.             
  257.                                                                      value = GetGadgetValue( wh->olist, GADGET_ID_CYCLE ) + MSG_CLICK_ME;
  258.                                                                             SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, value) );
  259.                                                                             break;
  260.             
  261.                                               case GADGET_ID_OKAY:   // doing a message
  262.                                                                      
  263.                                                                                         SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, MSG_OKAY_DONE) );
  264.                                                                             break;
  265.                                                      
  266.                                               case GADGET_ID_CANCEL: 
  267.                                                                      SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, MSG_CANCEL_DONE) );
  268.                                                                             break;
  269.                                           }
  270.                                                                  
  271.                                                   break;
  272.                                      
  273.                   case IDCMP_CLOSEWINDOW:
  274.                                           // we can not simply return here, the IntuiMessage must replied first
  275.                                                   
  276.                                                stop = TRUE;
  277.                                                   break;                                     
  278.               }
  279.                                  
  280.             ReplyWindowMsg( wh->imsg );  
  281.                               
  282.             // remember: You should not use any other routines
  283.             // to get/reply the messages of this window than
  284.             // GetWindowMsg() and ReplyWindowMsg() !!
  285.        }
  286.                                
  287.     return stop;
  288. }
  289.